package com.sloera.nowcoder;

import java.util.Scanner;

/**
 * class com.sloera.nowcoder
 * user sloera
 * date 2022/2/27
 */
public class HJ89 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            final String s = in.nextLine();
            String result = resolve(s);
            System.out.println(result);
        }
    }

    private static String resolve(String s) {
        // 3.输入4张牌为字符串形式，以一个空格隔开，首尾无空格；如果输入的4张牌中包含大小王，则输出字符串“ERROR”，表示无法运算；
        if (s.contains("joker") || s.contains("JOKER")) {
            return "ERROR";
        }
        final String[] split = s.split("\\s+");
        int[] input = new int[split.length];
        // 得到输入的数字
        // 2.牌面2~10对应的权值为2~10, J、Q、K、A权值分别为为11、12、13、1；
        for (int i = 0; i < split.length; i++) {
            switch (split[i]) {
                case "J":
                    input[i] = 11;
                    break;
                case "Q":
                    input[i] = 12;
                    break;
                case "K":
                    input[i] = 13;
                    break;
                case "A":
                    input[i] = 1;
                    break;
                default:
                    input[i] = Integer.parseInt(split[i]);
            }
        }
        // 计算是否能得到24点
        final char[] operators = new char[4];
        final int[] number = new int[4];
        boolean flag = canculate(operators, number, input, 24);
        if (flag) {
            final StringBuilder stringBuilder = new StringBuilder();
            for (int i = number.length - 1; i >= 0; i--) {
                if (i != number.length - 1 || operators[i] != '+') {
                    stringBuilder.append(operators[i]);
                }
                if (number[i] == 1) {
                    stringBuilder.append('A');
                } else if (number[i] == 11) {
                    stringBuilder.append('J');
                } else if (number[i] == 12) {
                    stringBuilder.append('Q');
                } else if (number[i] == 13) {
                    stringBuilder.append('K');
                } else {
                    stringBuilder.append(number[i]);
                }
            }
            return stringBuilder.toString();
        }
        return "NONE";
    }

    /**
     * 是否能由 input 中的数字，计算出sum
     *
     * @param operators 操作符记录
     * @param number 数字计算顺序
     * @param input 可选数字
     * @param sum 总数
     * @return boolean
     * @date 2022/2/27
     */
    private static boolean canculate(char[] operators, int[] number, int[] input, int sum) {
        if (input.length == 1) {
            if (input[0] == sum) {
                operators[3] = '+';
                number[3] = sum;
                return true;
            }
        }
        for (int i = 0; i < input.length; i++) {
            int[] newInput = getNewInput(input, i);
            //  ? = sum + input[i]
            if (canculate(operators, number, newInput, sum + input[i])) {
                // 这里记录的是input[i], ? 已经在递归里面记录了
                operators[operators.length - newInput.length - 1] = '-';
                // 这里记录的是input[i], ? 已经在递归里面记录了
                number[number.length - newInput.length - 1] = input[i];
                return true;
            }
            //  ? = sum - input[i]
            if (canculate(operators, number, newInput, sum - input[i])) {
                // 这里记录的是input[i], ? 已经在递归里面记录了
                operators[operators.length - newInput.length - 1] = '+';
                // 这里记录的是input[i], ? 已经在递归里面记录了
                number[number.length - newInput.length - 1] = input[i];
                return true;
            }
            //  ? = sum * input[i]
            if (canculate(operators, number, newInput, sum * input[i])) {
                // 这里记录的是input[i], ? 已经在递归里面记录了
                operators[operators.length - newInput.length - 1] = '/';
                // 这里记录的是input[i], ? 已经在递归里面记录了
                number[number.length - newInput.length - 1] = input[i];
                return true;
            }
            //  ? = sum / input[i]
            if (canculate(operators, number, newInput, sum / input[i]) && (sum % input[i] == 0)) {
                // 这里记录的是input[i], ? 已经在递归里面记录了
                operators[operators.length - newInput.length - 1] = '*';
                // 这里记录的是input[i], ? 已经在递归里面记录了
                number[number.length - newInput.length - 1] = input[i];
                return true;
            }
        }
        return false;
    }

    /**
     * 获取input中，除index索引所在位置的新数组
     *
     * @param input 原始数组
     * @param index 待去除索引
     * @return int[]
     * @date 2022/2/27
     */
    private static int[] getNewInput(int[] input, int index) {
        final int[] ints = new int[input.length - 1];
        int j = 0;
        for (int i = 0; i < input.length; i++) {
            if (i != index) {
                ints[j++] = input[i];
            }
        }
        return ints;
    }
}